package internal

import (
	"fmt"
	"time"

	"baseService/internal/infrastructure/config"
	"baseService/internal/infrastructure/persistence"
	pkgcache "baseService/internal/pkg/cache"
	pkgeventbus "baseService/internal/pkg/eventbus"
	pkglogger "baseService/internal/pkg/logger"
	"baseService/internal/pkg/validator"

	"gorm.io/gorm"
)

// Dependencies 应用程序依赖集合 - 类型安全的依赖注入
type Dependencies struct {
	// 核心配置
	Config        *config.Config
	ConfigManager *config.ConfigManager

	// 日志系统
	Logger pkglogger.Logger

	// 数据库
	DatabaseManager *persistence.DatabaseManager
	DB              *gorm.DB // 方便直接访问

	// 缓存系统 - 极简版本
	Cache pkgcache.Cache // 直接访问缓存实例

	// 事件总线 - 使用依赖注入避免循环依赖
	EventBus *pkgeventbus.EventBus
}

// NewDependencies 创建并初始化所有依赖
func NewDependencies(configPath string) (*Dependencies, error) {
	deps := &Dependencies{}

	// 初始化配置 - 最高优先级
	if err := deps.initConfig(configPath); err != nil {
		return nil, fmt.Errorf("初始化配置失败: %w", err)
	}

	// 初始化日志 - 第二优先级，后续所有组件都需要日志
	if err := deps.initLogger(); err != nil {
		return nil, fmt.Errorf("初始化日志失败: %w", err)
	}

	// 初始化验证器 - 无依赖，可以早期初始化
	if err := deps.initValidator(); err != nil {
		return nil, fmt.Errorf("初始化验证器失败: %w", err)
	}

	// 初始化缓存系统 - 依赖配置和日志
	if err := deps.initCache(); err != nil {
		return nil, fmt.Errorf("初始化缓存系统失败: %w", err)
	}

	// 初始化数据库 - 依赖配置和日志
	if err := deps.initDatabase(); err != nil {
		return nil, fmt.Errorf("初始化数据库失败: %w", err)
	}

	// 初始化事件总线 - 使用依赖注入
	if err := deps.initEventBus(); err != nil {
		return nil, fmt.Errorf("初始化事件总线失败: %w", err)
	}

	deps.Logger.Info("所有依赖初始化成功")
	return deps, nil
}

// initConfig 初始化配置
func (deps *Dependencies) initConfig(configPath string) error {
	configManager, err := config.NewConfigManager(configPath)
	if err != nil {
		return err
	}

	deps.ConfigManager = configManager
	deps.Config = configManager.GetConfig()
	return nil
}

// initLogger 初始化日志 - 使用环境感知配置
func (deps *Dependencies) initLogger() error {
	// 直接使用环境自动配置
	logger, err := pkglogger.NewEnvironmentLogger(deps.Config.App.Environment)
	if err != nil {
		return err
	}

	deps.Logger = logger

	// 设置全局日志实例
	pkglogger.SetGlobalLogger(deps.Logger)

	deps.Logger.Info("日志系统初始化成功")
	return nil
}

// initValidator 初始化验证器
func (deps *Dependencies) initValidator() error {
	// 默认使用中文
	locale := "zh"
	if deps.Config.App.Locale != "" {
		locale = deps.Config.App.Locale
	}

	if err := validator.Init(locale); err != nil {
		return fmt.Errorf("初始化验证器失败: %w", err)
	}

	deps.Logger.Info("验证器初始化成功")
	return nil
}

// initCache 初始化缓存系统 - 从配置文件读取
func (deps *Dependencies) initCache() error {
	// 从配置文件构建缓存配置
	cfg := &pkgcache.CacheConfig{
		Engine:          deps.Config.Cache.Engine,
		DefaultTTL:      parseDurationOrDefault(deps.Config.Cache.DefaultTTL, 30*time.Minute),
		RedisURL:        deps.Config.Cache.Redis.URL,
		RedisPrefix:     deps.Config.Cache.Redis.Prefix,
		MaxItems:        deps.Config.Cache.Memory.MaxItems,
		CleanupInterval: parseDurationOrDefault(deps.Config.Cache.Memory.CleanupInterval, 5*time.Minute),
	}

	// 创建缓存实例
	cache, err := pkgcache.NewCacheWithConfig(cfg, deps.Logger)
	if err != nil {
		return fmt.Errorf("创建缓存失败: %w", err)
	}

	deps.Cache = cache
	deps.Logger.Infof("缓存系统初始化成功 - engine: %s, ttl: %s", cfg.Engine, cfg.DefaultTTL)
	return nil
}

// parseDurationOrDefault 解析时间字符串
func parseDurationOrDefault(s string, defaultValue time.Duration) time.Duration {
	if d, err := time.ParseDuration(s); err == nil {
		return d
	}
	return defaultValue
}

// initDatabase 初始化数据库
func (deps *Dependencies) initDatabase() error {
	// 创建数据库管理器
	deps.DatabaseManager = persistence.NewDatabaseManager(deps.Config, deps.Logger)

	// 初始化数据库连接
	if err := deps.DatabaseManager.Initialize(); err != nil {
		return fmt.Errorf("初始化数据库连接失败: %w", err)
	}

	// 方便直接访问的DB实例
	deps.DB = deps.DatabaseManager.GetDB()

	// 执行数据库迁移
	if deps.Config.Database.AutoMigrate {
		deps.Logger.Info("开始执行数据库自动迁移...")
		if err := deps.DatabaseManager.Migrate(); err != nil {
			return fmt.Errorf("数据库迁移失败: %w", err)
		}
		deps.Logger.Info("数据库迁移完成")
	}

	deps.Logger.Info("数据库系统初始化成功")
	return nil
}

// initEventBus 初始化事件总线
func (deps *Dependencies) initEventBus() error {
	// 使用全局的 DefaultBus
	deps.EventBus = pkgeventbus.DefaultBus
	deps.Logger.Info("事件总线初始化成功")
	return nil
}

// Close 优雅关闭所有依赖资源
func (deps *Dependencies) Close() error {
	deps.Logger.Info("开始关闭依赖资源")

	// EventBus 无需关闭（goroutine 会自然结束）

	// 关闭缓存
	if deps.Cache != nil {
		deps.Logger.Info("关闭缓存系统")
		if err := deps.Cache.Close(); err != nil {
			deps.Logger.Errorf("缓存关闭失败: %v", err)
		}
	}

	// 关闭数据库连接
	if deps.DatabaseManager != nil {
		deps.Logger.Info("关闭数据库连接")
		if err := deps.DatabaseManager.Close(); err != nil {
			deps.Logger.Errorf("数据库连接关闭失败: %v", err)
		}
	}

	deps.Logger.Info("所有依赖资源关闭完成")
	return nil
}

// GetDB 获取数据库连接 - 实现ApplicationInterface
func (deps *Dependencies) GetDB() *gorm.DB {
	return deps.DB
}

// GetCache 获取缓存实例 - 实现ApplicationInterface
func (deps *Dependencies) GetCache() pkgcache.Cache {
	return deps.Cache
}

// GetEventBusManager 获取事件总线管理器 - 实现ApplicationInterface
func (deps *Dependencies) GetEventBusManager() *pkgeventbus.EventBus {
	return deps.EventBus
}

// GetConfig 获取配置 - 实现ApplicationInterface
func (deps *Dependencies) GetConfig() *config.Config {
	return deps.Config
}

// GetLogger 获取日志器 - 实现ApplicationInterface
func (deps *Dependencies) GetLogger() pkglogger.Logger {
	return deps.Logger
}

// GetConnectionStats 获取数据库连接池统计信息 - 实现ApplicationInterface
func (deps *Dependencies) GetConnectionStats() (map[string]interface{}, error) {
	if deps.DatabaseManager == nil {
		return nil, fmt.Errorf("数据库管理器未初始化")
	}
	return deps.DatabaseManager.GetConnectionStats()
}

// 确保 Dependencies 实现了 ApplicationInterface
var _ ApplicationInterface = (*Dependencies)(nil)
